home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 60 / IOPROG_60.ISO / soft / c++ / gsl-1.1.1-setup.exe / {app} / src / cblas / test_scal.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-04-18  |  21.4 KB  |  912 lines
  1. #include <gsl/gsl_test.h>
  2. #include <gsl/gsl_ieee_utils.h>
  3. #include <gsl/gsl_math.h>
  4. #include <gsl/gsl_cblas.h>
  5.  
  6. #include "tests.h"
  7.  
  8. void
  9. test_scal (void) {
  10. const double flteps = 1e-4, dbleps = 1e-6;
  11.   {
  12.    int N = 1;
  13.    float alpha = 0.0f;
  14.    float X[] = { 0.651f };
  15.    int incX = -1;
  16.    float expected[] = { 0.651f };
  17.    cblas_sscal(N, alpha, X, incX);
  18.    {
  19.      int i;
  20.      for (i = 0; i < 1; i++) {
  21.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 112)");
  22.      }
  23.    };
  24.   };
  25.  
  26.  
  27.   {
  28.    int N = 1;
  29.    float alpha = 0.1f;
  30.    float X[] = { 0.651f };
  31.    int incX = -1;
  32.    float expected[] = { 0.651f };
  33.    cblas_sscal(N, alpha, X, incX);
  34.    {
  35.      int i;
  36.      for (i = 0; i < 1; i++) {
  37.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 113)");
  38.      }
  39.    };
  40.   };
  41.  
  42.  
  43.   {
  44.    int N = 1;
  45.    float alpha = 1.0f;
  46.    float X[] = { 0.651f };
  47.    int incX = -1;
  48.    float expected[] = { 0.651f };
  49.    cblas_sscal(N, alpha, X, incX);
  50.    {
  51.      int i;
  52.      for (i = 0; i < 1; i++) {
  53.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 114)");
  54.      }
  55.    };
  56.   };
  57.  
  58.  
  59.   {
  60.    int N = 1;
  61.    double alpha = 0;
  62.    double X[] = { 0.686 };
  63.    int incX = -1;
  64.    double expected[] = { 0.686 };
  65.    cblas_dscal(N, alpha, X, incX);
  66.    {
  67.      int i;
  68.      for (i = 0; i < 1; i++) {
  69.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 115)");
  70.      }
  71.    };
  72.   };
  73.  
  74.  
  75.   {
  76.    int N = 1;
  77.    double alpha = 0.1;
  78.    double X[] = { 0.686 };
  79.    int incX = -1;
  80.    double expected[] = { 0.686 };
  81.    cblas_dscal(N, alpha, X, incX);
  82.    {
  83.      int i;
  84.      for (i = 0; i < 1; i++) {
  85.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 116)");
  86.      }
  87.    };
  88.   };
  89.  
  90.  
  91.   {
  92.    int N = 1;
  93.    double alpha = 1;
  94.    double X[] = { 0.686 };
  95.    int incX = -1;
  96.    double expected[] = { 0.686 };
  97.    cblas_dscal(N, alpha, X, incX);
  98.    {
  99.      int i;
  100.      for (i = 0; i < 1; i++) {
  101.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 117)");
  102.      }
  103.    };
  104.   };
  105.  
  106.  
  107.   {
  108.    int N = 1;
  109.    float alpha[2] = {0.0f, 0.0f};
  110.    float X[] = { 0.986f, -0.775f };
  111.    int incX = -1;
  112.    float expected[] = { 0.986f, -0.775f };
  113.    cblas_cscal(N, alpha, X, incX);
  114.    {
  115.      int i;
  116.      for (i = 0; i < 1; i++) {
  117.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 118) real");
  118.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 118) imag");
  119.      };
  120.    };
  121.   };
  122.  
  123.  
  124.   {
  125.    int N = 1;
  126.    float alpha[2] = {0.1f, 0.0f};
  127.    float X[] = { 0.986f, -0.775f };
  128.    int incX = -1;
  129.    float expected[] = { 0.986f, -0.775f };
  130.    cblas_cscal(N, alpha, X, incX);
  131.    {
  132.      int i;
  133.      for (i = 0; i < 1; i++) {
  134.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 119) real");
  135.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 119) imag");
  136.      };
  137.    };
  138.   };
  139.  
  140.  
  141.   {
  142.    int N = 1;
  143.    float alpha[2] = {1.0f, 0.0f};
  144.    float X[] = { 0.986f, -0.775f };
  145.    int incX = -1;
  146.    float expected[] = { 0.986f, -0.775f };
  147.    cblas_cscal(N, alpha, X, incX);
  148.    {
  149.      int i;
  150.      for (i = 0; i < 1; i++) {
  151.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 120) real");
  152.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 120) imag");
  153.      };
  154.    };
  155.   };
  156.  
  157.  
  158.   {
  159.    int N = 1;
  160.    float alpha[2] = {0.0f, 0.1f};
  161.    float X[] = { 0.986f, -0.775f };
  162.    int incX = -1;
  163.    float expected[] = { 0.986f, -0.775f };
  164.    cblas_cscal(N, alpha, X, incX);
  165.    {
  166.      int i;
  167.      for (i = 0; i < 1; i++) {
  168.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 121) real");
  169.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 121) imag");
  170.      };
  171.    };
  172.   };
  173.  
  174.  
  175.   {
  176.    int N = 1;
  177.    float alpha[2] = {0.1f, 0.2f};
  178.    float X[] = { 0.986f, -0.775f };
  179.    int incX = -1;
  180.    float expected[] = { 0.986f, -0.775f };
  181.    cblas_cscal(N, alpha, X, incX);
  182.    {
  183.      int i;
  184.      for (i = 0; i < 1; i++) {
  185.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 122) real");
  186.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 122) imag");
  187.      };
  188.    };
  189.   };
  190.  
  191.  
  192.   {
  193.    int N = 1;
  194.    float alpha[2] = {1.0f, 0.3f};
  195.    float X[] = { 0.986f, -0.775f };
  196.    int incX = -1;
  197.    float expected[] = { 0.986f, -0.775f };
  198.    cblas_cscal(N, alpha, X, incX);
  199.    {
  200.      int i;
  201.      for (i = 0; i < 1; i++) {
  202.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 123) real");
  203.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 123) imag");
  204.      };
  205.    };
  206.   };
  207.  
  208.  
  209.   {
  210.    int N = 1;
  211.    double alpha[2] = {0, 0};
  212.    double X[] = { 0.454, -0.478 };
  213.    int incX = -1;
  214.    double expected[] = { 0.454, -0.478 };
  215.    cblas_zscal(N, alpha, X, incX);
  216.    {
  217.      int i;
  218.      for (i = 0; i < 1; i++) {
  219.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 124) real");
  220.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 124) imag");
  221.      };
  222.    };
  223.   };
  224.  
  225.  
  226.   {
  227.    int N = 1;
  228.    double alpha[2] = {0.1, 0};
  229.    double X[] = { 0.454, -0.478 };
  230.    int incX = -1;
  231.    double expected[] = { 0.454, -0.478 };
  232.    cblas_zscal(N, alpha, X, incX);
  233.    {
  234.      int i;
  235.      for (i = 0; i < 1; i++) {
  236.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 125) real");
  237.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 125) imag");
  238.      };
  239.    };
  240.   };
  241.  
  242.  
  243.   {
  244.    int N = 1;
  245.    double alpha[2] = {1, 0};
  246.    double X[] = { 0.454, -0.478 };
  247.    int incX = -1;
  248.    double expected[] = { 0.454, -0.478 };
  249.    cblas_zscal(N, alpha, X, incX);
  250.    {
  251.      int i;
  252.      for (i = 0; i < 1; i++) {
  253.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 126) real");
  254.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 126) imag");
  255.      };
  256.    };
  257.   };
  258.  
  259.  
  260.   {
  261.    int N = 1;
  262.    double alpha[2] = {0, 0.1};
  263.    double X[] = { 0.454, -0.478 };
  264.    int incX = -1;
  265.    double expected[] = { 0.454, -0.478 };
  266.    cblas_zscal(N, alpha, X, incX);
  267.    {
  268.      int i;
  269.      for (i = 0; i < 1; i++) {
  270.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 127) real");
  271.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 127) imag");
  272.      };
  273.    };
  274.   };
  275.  
  276.  
  277.   {
  278.    int N = 1;
  279.    double alpha[2] = {0.1, 0.2};
  280.    double X[] = { 0.454, -0.478 };
  281.    int incX = -1;
  282.    double expected[] = { 0.454, -0.478 };
  283.    cblas_zscal(N, alpha, X, incX);
  284.    {
  285.      int i;
  286.      for (i = 0; i < 1; i++) {
  287.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 128) real");
  288.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 128) imag");
  289.      };
  290.    };
  291.   };
  292.  
  293.  
  294.   {
  295.    int N = 1;
  296.    double alpha[2] = {1, 0.3};
  297.    double X[] = { 0.454, -0.478 };
  298.    int incX = -1;
  299.    double expected[] = { 0.454, -0.478 };
  300.    cblas_zscal(N, alpha, X, incX);
  301.    {
  302.      int i;
  303.      for (i = 0; i < 1; i++) {
  304.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 129) real");
  305.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 129) imag");
  306.      };
  307.    };
  308.   };
  309.  
  310.  
  311.   {
  312.    int N = 2;
  313.    float alpha = 0.0f;
  314.    float X[] = { 0.389f, -0.236f };
  315.    int incX = 1;
  316.    float expected[] = { 0.0f, -0.0f };
  317.    cblas_sscal(N, alpha, X, incX);
  318.    {
  319.      int i;
  320.      for (i = 0; i < 2; i++) {
  321.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 130)");
  322.      }
  323.    };
  324.   };
  325.  
  326.  
  327.   {
  328.    int N = 2;
  329.    float alpha = 0.1f;
  330.    float X[] = { 0.389f, -0.236f };
  331.    int incX = 1;
  332.    float expected[] = { 0.0389f, -0.0236f };
  333.    cblas_sscal(N, alpha, X, incX);
  334.    {
  335.      int i;
  336.      for (i = 0; i < 2; i++) {
  337.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 131)");
  338.      }
  339.    };
  340.   };
  341.  
  342.  
  343.   {
  344.    int N = 2;
  345.    float alpha = 1.0f;
  346.    float X[] = { 0.389f, -0.236f };
  347.    int incX = 1;
  348.    float expected[] = { 0.389f, -0.236f };
  349.    cblas_sscal(N, alpha, X, incX);
  350.    {
  351.      int i;
  352.      for (i = 0; i < 2; i++) {
  353.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 132)");
  354.      }
  355.    };
  356.   };
  357.  
  358.  
  359.   {
  360.    int N = 2;
  361.    double alpha = 0;
  362.    double X[] = { -0.429, -0.183 };
  363.    int incX = 1;
  364.    double expected[] = { -0.0, -0.0 };
  365.    cblas_dscal(N, alpha, X, incX);
  366.    {
  367.      int i;
  368.      for (i = 0; i < 2; i++) {
  369.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 133)");
  370.      }
  371.    };
  372.   };
  373.  
  374.  
  375.   {
  376.    int N = 2;
  377.    double alpha = 0.1;
  378.    double X[] = { -0.429, -0.183 };
  379.    int incX = 1;
  380.    double expected[] = { -0.0429, -0.0183 };
  381.    cblas_dscal(N, alpha, X, incX);
  382.    {
  383.      int i;
  384.      for (i = 0; i < 2; i++) {
  385.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 134)");
  386.      }
  387.    };
  388.   };
  389.  
  390.  
  391.   {
  392.    int N = 2;
  393.    double alpha = 1;
  394.    double X[] = { -0.429, -0.183 };
  395.    int incX = 1;
  396.    double expected[] = { -0.429, -0.183 };
  397.    cblas_dscal(N, alpha, X, incX);
  398.    {
  399.      int i;
  400.      for (i = 0; i < 2; i++) {
  401.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 135)");
  402.      }
  403.    };
  404.   };
  405.  
  406.  
  407.   {
  408.    int N = 2;
  409.    float alpha[2] = {0.0f, 0.0f};
  410.    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  411.    int incX = 1;
  412.    float expected[] = { -0.0f, 0.0f, 0.0f, 0.0f };
  413.    cblas_cscal(N, alpha, X, incX);
  414.    {
  415.      int i;
  416.      for (i = 0; i < 2; i++) {
  417.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 136) real");
  418.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 136) imag");
  419.      };
  420.    };
  421.   };
  422.  
  423.  
  424.   {
  425.    int N = 2;
  426.    float alpha[2] = {0.1f, 0.0f};
  427.    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  428.    int incX = 1;
  429.    float expected[] = { -0.0603f, 0.0239f, 0.0339f, -0.058f };
  430.    cblas_cscal(N, alpha, X, incX);
  431.    {
  432.      int i;
  433.      for (i = 0; i < 2; i++) {
  434.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 137) real");
  435.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 137) imag");
  436.      };
  437.    };
  438.   };
  439.  
  440.  
  441.   {
  442.    int N = 2;
  443.    float alpha[2] = {1.0f, 0.0f};
  444.    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  445.    int incX = 1;
  446.    float expected[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  447.    cblas_cscal(N, alpha, X, incX);
  448.    {
  449.      int i;
  450.      for (i = 0; i < 2; i++) {
  451.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 138) real");
  452.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 138) imag");
  453.      };
  454.    };
  455.   };
  456.  
  457.  
  458.   {
  459.    int N = 2;
  460.    float alpha[2] = {0.0f, 0.1f};
  461.    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  462.    int incX = 1;
  463.    float expected[] = { -0.0239f, -0.0603f, 0.058f, 0.0339f };
  464.    cblas_cscal(N, alpha, X, incX);
  465.    {
  466.      int i;
  467.      for (i = 0; i < 2; i++) {
  468.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 139) real");
  469.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 139) imag");
  470.      };
  471.    };
  472.   };
  473.  
  474.  
  475.   {
  476.    int N = 2;
  477.    float alpha[2] = {0.1f, 0.2f};
  478.    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  479.    int incX = 1;
  480.    float expected[] = { -0.1081f, -0.0967f, 0.1499f, 0.0098f };
  481.    cblas_cscal(N, alpha, X, incX);
  482.    {
  483.      int i;
  484.      for (i = 0; i < 2; i++) {
  485.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 140) real");
  486.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 140) imag");
  487.      };
  488.    };
  489.   };
  490.  
  491.  
  492.   {
  493.    int N = 2;
  494.    float alpha[2] = {1.0f, 0.3f};
  495.    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
  496.    int incX = 1;
  497.    float expected[] = { -0.6747f, 0.0581f, 0.513f, -0.4783f };
  498.    cblas_cscal(N, alpha, X, incX);
  499.    {
  500.      int i;
  501.      for (i = 0; i < 2; i++) {
  502.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 141) real");
  503.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 141) imag");
  504.      };
  505.    };
  506.   };
  507.  
  508.  
  509.   {
  510.    int N = 2;
  511.    double alpha[2] = {0, 0};
  512.    double X[] = { -0.956, 0.613, 0.443, 0.503 };
  513.    int incX = 1;
  514.    double expected[] = { -0.0, 0.0, 0.0, 0.0 };
  515.    cblas_zscal(N, alpha, X, incX);
  516.    {
  517.      int i;
  518.      for (i = 0; i < 2; i++) {
  519.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 142) real");
  520.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 142) imag");
  521.      };
  522.    };
  523.   };
  524.  
  525.  
  526.   {
  527.    int N = 2;
  528.    double alpha[2] = {0.1, 0};
  529.    double X[] = { -0.956, 0.613, 0.443, 0.503 };
  530.    int incX = 1;
  531.    double expected[] = { -0.0956, 0.0613, 0.0443, 0.0503 };
  532.    cblas_zscal(N, alpha, X, incX);
  533.    {
  534.      int i;
  535.      for (i = 0; i < 2; i++) {
  536.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 143) real");
  537.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 143) imag");
  538.      };
  539.    };
  540.   };
  541.  
  542.  
  543.   {
  544.    int N = 2;
  545.    double alpha[2] = {1, 0};
  546.    double X[] = { -0.956, 0.613, 0.443, 0.503 };
  547.    int incX = 1;
  548.    double expected[] = { -0.956, 0.613, 0.443, 0.503 };
  549.    cblas_zscal(N, alpha, X, incX);
  550.    {
  551.      int i;
  552.      for (i = 0; i < 2; i++) {
  553.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 144) real");
  554.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 144) imag");
  555.      };
  556.    };
  557.   };
  558.  
  559.  
  560.   {
  561.    int N = 2;
  562.    double alpha[2] = {0, 0.1};
  563.    double X[] = { -0.956, 0.613, 0.443, 0.503 };
  564.    int incX = 1;
  565.    double expected[] = { -0.0613, -0.0956, -0.0503, 0.0443 };
  566.    cblas_zscal(N, alpha, X, incX);
  567.    {
  568.      int i;
  569.      for (i = 0; i < 2; i++) {
  570.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 145) real");
  571.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 145) imag");
  572.      };
  573.    };
  574.   };
  575.  
  576.  
  577.   {
  578.    int N = 2;
  579.    double alpha[2] = {0.1, 0.2};
  580.    double X[] = { -0.956, 0.613, 0.443, 0.503 };
  581.    int incX = 1;
  582.    double expected[] = { -0.2182, -0.1299, -0.0563, 0.1389 };
  583.    cblas_zscal(N, alpha, X, incX);
  584.    {
  585.      int i;
  586.      for (i = 0; i < 2; i++) {
  587.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 146) real");
  588.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 146) imag");
  589.      };
  590.    };
  591.   };
  592.  
  593.  
  594.   {
  595.    int N = 2;
  596.    double alpha[2] = {1, 0.3};
  597.    double X[] = { -0.956, 0.613, 0.443, 0.503 };
  598.    int incX = 1;
  599.    double expected[] = { -1.1399, 0.3262, 0.2921, 0.6359 };
  600.    cblas_zscal(N, alpha, X, incX);
  601.    {
  602.      int i;
  603.      for (i = 0; i < 2; i++) {
  604.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 147) real");
  605.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 147) imag");
  606.      };
  607.    };
  608.   };
  609.  
  610.  
  611.   {
  612.    int N = 2;
  613.    float alpha = 0.0f;
  614.    float X[] = { 0.629f, -0.419f };
  615.    int incX = -1;
  616.    float expected[] = { 0.629f, -0.419f };
  617.    cblas_sscal(N, alpha, X, incX);
  618.    {
  619.      int i;
  620.      for (i = 0; i < 2; i++) {
  621.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 148)");
  622.      }
  623.    };
  624.   };
  625.  
  626.  
  627.   {
  628.    int N = 2;
  629.    float alpha = 0.1f;
  630.    float X[] = { 0.629f, -0.419f };
  631.    int incX = -1;
  632.    float expected[] = { 0.629f, -0.419f };
  633.    cblas_sscal(N, alpha, X, incX);
  634.    {
  635.      int i;
  636.      for (i = 0; i < 2; i++) {
  637.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 149)");
  638.      }
  639.    };
  640.   };
  641.  
  642.  
  643.   {
  644.    int N = 2;
  645.    float alpha = 1.0f;
  646.    float X[] = { 0.629f, -0.419f };
  647.    int incX = -1;
  648.    float expected[] = { 0.629f, -0.419f };
  649.    cblas_sscal(N, alpha, X, incX);
  650.    {
  651.      int i;
  652.      for (i = 0; i < 2; i++) {
  653.        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 150)");
  654.      }
  655.    };
  656.   };
  657.  
  658.  
  659.   {
  660.    int N = 2;
  661.    double alpha = 0;
  662.    double X[] = { 0.398, -0.656 };
  663.    int incX = -1;
  664.    double expected[] = { 0.398, -0.656 };
  665.    cblas_dscal(N, alpha, X, incX);
  666.    {
  667.      int i;
  668.      for (i = 0; i < 2; i++) {
  669.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 151)");
  670.      }
  671.    };
  672.   };
  673.  
  674.  
  675.   {
  676.    int N = 2;
  677.    double alpha = 0.1;
  678.    double X[] = { 0.398, -0.656 };
  679.    int incX = -1;
  680.    double expected[] = { 0.398, -0.656 };
  681.    cblas_dscal(N, alpha, X, incX);
  682.    {
  683.      int i;
  684.      for (i = 0; i < 2; i++) {
  685.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 152)");
  686.      }
  687.    };
  688.   };
  689.  
  690.  
  691.   {
  692.    int N = 2;
  693.    double alpha = 1;
  694.    double X[] = { 0.398, -0.656 };
  695.    int incX = -1;
  696.    double expected[] = { 0.398, -0.656 };
  697.    cblas_dscal(N, alpha, X, incX);
  698.    {
  699.      int i;
  700.      for (i = 0; i < 2; i++) {
  701.        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 153)");
  702.      }
  703.    };
  704.   };
  705.  
  706.  
  707.   {
  708.    int N = 2;
  709.    float alpha[2] = {0.0f, 0.0f};
  710.    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  711.    int incX = -1;
  712.    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  713.    cblas_cscal(N, alpha, X, incX);
  714.    {
  715.      int i;
  716.      for (i = 0; i < 2; i++) {
  717.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 154) real");
  718.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 154) imag");
  719.      };
  720.    };
  721.   };
  722.  
  723.  
  724.   {
  725.    int N = 2;
  726.    float alpha[2] = {0.1f, 0.0f};
  727.    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  728.    int incX = -1;
  729.    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  730.    cblas_cscal(N, alpha, X, incX);
  731.    {
  732.      int i;
  733.      for (i = 0; i < 2; i++) {
  734.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 155) real");
  735.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 155) imag");
  736.      };
  737.    };
  738.   };
  739.  
  740.  
  741.   {
  742.    int N = 2;
  743.    float alpha[2] = {1.0f, 0.0f};
  744.    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  745.    int incX = -1;
  746.    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  747.    cblas_cscal(N, alpha, X, incX);
  748.    {
  749.      int i;
  750.      for (i = 0; i < 2; i++) {
  751.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 156) real");
  752.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 156) imag");
  753.      };
  754.    };
  755.   };
  756.  
  757.  
  758.   {
  759.    int N = 2;
  760.    float alpha[2] = {0.0f, 0.1f};
  761.    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  762.    int incX = -1;
  763.    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  764.    cblas_cscal(N, alpha, X, incX);
  765.    {
  766.      int i;
  767.      for (i = 0; i < 2; i++) {
  768.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 157) real");
  769.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 157) imag");
  770.      };
  771.    };
  772.   };
  773.  
  774.  
  775.   {
  776.    int N = 2;
  777.    float alpha[2] = {0.1f, 0.2f};
  778.    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  779.    int incX = -1;
  780.    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  781.    cblas_cscal(N, alpha, X, incX);
  782.    {
  783.      int i;
  784.      for (i = 0; i < 2; i++) {
  785.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 158) real");
  786.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 158) imag");
  787.      };
  788.    };
  789.   };
  790.  
  791.  
  792.   {
  793.    int N = 2;
  794.    float alpha[2] = {1.0f, 0.3f};
  795.    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  796.    int incX = -1;
  797.    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
  798.    cblas_cscal(N, alpha, X, incX);
  799.    {
  800.      int i;
  801.      for (i = 0; i < 2; i++) {
  802.        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 159) real");
  803.        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 159) imag");
  804.      };
  805.    };
  806.   };
  807.  
  808.  
  809.   {
  810.    int N = 2;
  811.    double alpha[2] = {0, 0};
  812.    double X[] = { 0.521, -0.811, 0.556, -0.147 };
  813.    int incX = -1;
  814.    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
  815.    cblas_zscal(N, alpha, X, incX);
  816.    {
  817.      int i;
  818.      for (i = 0; i < 2; i++) {
  819.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 160) real");
  820.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 160) imag");
  821.      };
  822.    };
  823.   };
  824.  
  825.  
  826.   {
  827.    int N = 2;
  828.    double alpha[2] = {0.1, 0};
  829.    double X[] = { 0.521, -0.811, 0.556, -0.147 };
  830.    int incX = -1;
  831.    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
  832.    cblas_zscal(N, alpha, X, incX);
  833.    {
  834.      int i;
  835.      for (i = 0; i < 2; i++) {
  836.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 161) real");
  837.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 161) imag");
  838.      };
  839.    };
  840.   };
  841.  
  842.  
  843.   {
  844.    int N = 2;
  845.    double alpha[2] = {1, 0};
  846.    double X[] = { 0.521, -0.811, 0.556, -0.147 };
  847.    int incX = -1;
  848.    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
  849.    cblas_zscal(N, alpha, X, incX);
  850.    {
  851.      int i;
  852.      for (i = 0; i < 2; i++) {
  853.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 162) real");
  854.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 162) imag");
  855.      };
  856.    };
  857.   };
  858.  
  859.  
  860.   {
  861.    int N = 2;
  862.    double alpha[2] = {0, 0.1};
  863.    double X[] = { 0.521, -0.811, 0.556, -0.147 };
  864.    int incX = -1;
  865.    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
  866.    cblas_zscal(N, alpha, X, incX);
  867.    {
  868.      int i;
  869.      for (i = 0; i < 2; i++) {
  870.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 163) real");
  871.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 163) imag");
  872.      };
  873.    };
  874.   };
  875.  
  876.  
  877.   {
  878.    int N = 2;
  879.    double alpha[2] = {0.1, 0.2};
  880.    double X[] = { 0.521, -0.811, 0.556, -0.147 };
  881.    int incX = -1;
  882.    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
  883.    cblas_zscal(N, alpha, X, incX);
  884.    {
  885.      int i;
  886.      for (i = 0; i < 2; i++) {
  887.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 164) real");
  888.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 164) imag");
  889.      };
  890.    };
  891.   };
  892.  
  893.  
  894.   {
  895.    int N = 2;
  896.    double alpha[2] = {1, 0.3};
  897.    double X[] = { 0.521, -0.811, 0.556, -0.147 };
  898.    int incX = -1;
  899.    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
  900.    cblas_zscal(N, alpha, X, incX);
  901.    {
  902.      int i;
  903.      for (i = 0; i < 2; i++) {
  904.        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 165) real");
  905.        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 165) imag");
  906.      };
  907.    };
  908.   };
  909.  
  910.  
  911. }
  912.